home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / String.C < prev    next >
C/C++ Source or Header  |  1992-07-08  |  5KB  |  247 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "String.h"
  6. #include "Error.h"
  7.  
  8. extern "C" void bcopy(const void *, void *, size_t);
  9.  
  10. void MemCpy(void *to, const void *from, size_t len)
  11. {
  12.     bcopy(from, to, len);
  13. }
  14.  
  15. void *memcpy(void *to, const void *from, size_t len)
  16. {
  17.     if (to == 0 && len != 0)
  18.     fprintf(stderr, "memcpy, to == 0\n");
  19.     if (from == 0 && len != 0)
  20.     fprintf(stderr, "memcpy, from == 0\n");
  21.     bcopy(from, to, len);
  22.     return to;
  23. }
  24.  
  25. int StuffChar(char *src, char *dst, int dstlen, char* specchars, char stuffchar)
  26. {
  27.     register char *p, *q, *end;
  28.  
  29.     end= dst+dstlen-1;
  30.  
  31.     for (p= src, q= dst; *p && q < end; ) {
  32.     if (strchr(specchars, *p)) {
  33.         *q++= stuffchar;
  34.         if (q < end)
  35.         *q++= *p++;
  36.     } else 
  37.         *q++= *p++;
  38.     }
  39.     *q= '\0';
  40.  
  41.     if (*p != 0)
  42.     return -1;
  43.     return q-dst;
  44. }
  45.  
  46. char *strsave(char *s, int l)
  47. {
  48.     if (s == 0 || l == 0)
  49.     return 0;
  50.     if (l < 0)
  51.     l= strlen(s)+1;
  52.     char *str= new char[l];
  53.     return strncpy(str, s, l);
  54. }
  55.  
  56. char *strreplace(char **s, char *r, int l)
  57. {
  58.     if (s == 0)
  59.     Fatal("strreplace", "s == 0, replace: %s l: %d", r, l);
  60.     if (r == 0 || l == 0)
  61.     return *s;
  62.     if (l < 0)
  63.     l= strlen(r)+1;
  64.     *s= (char*) Realloc(*s, l);
  65.     return strncpy(*s, r, l);
  66. }
  67.  
  68. char *strfreplace(char **s, char *fmt, va_list ap)
  69. {
  70.     char buf[1000];
  71.  
  72.     if (s == 0)
  73.     Fatal("strfreplace", "s == 0, fmt: %s", fmt);
  74.     if (fmt == 0)
  75.     return *s;
  76.  
  77.     vsprintf(buf, fmt, ap);
  78.  
  79.     *s= (char*) Realloc(*s, strlen(buf)+1);
  80.     return strcpy(*s, buf);
  81. }
  82.  
  83. char *strprintf(char *va_(fmt), ...)
  84. {
  85.     va_list ap;
  86.     char buf[2000];
  87.  
  88.     va_start(ap,va_(fmt));
  89.     vsprintf(buf, va_(fmt), ap);
  90.     va_end(ap);
  91.     return strsave(buf);
  92. }
  93.  
  94. char* strvprintf(char* fmt, va_list ap)
  95. {       
  96.     char buf[2000];
  97.     vsprintf(buf, fmt, ap);
  98.     return strsave(buf);
  99. }
  100.  
  101. bool strismember(const char *va_(cp), ...)
  102. {
  103.     char *s;   
  104.     va_list ap;
  105.     bool found= FALSE;
  106.     va_start(ap,va_(cp));
  107.     for (int i= 0; s= va_arg(ap, char*); i++)  
  108.     if (strcmp(va_(cp), s) == 0) {
  109.         found= TRUE;
  110.         break;
  111.     }
  112.     va_end(ap);
  113.     return found;
  114. }
  115.  
  116. char* strn0cpy(char *dst, const char *src, int l)
  117. {
  118.     strncpy(dst, src, l-1);
  119.     dst[l-1]= '\0';
  120.     return dst;
  121. }
  122.  
  123. u_long strhash(const byte *str)
  124. {
  125.     register u_long h= 0, g;
  126.     register const byte *p= str;
  127.  
  128.     while (*p != 0) {
  129.     h= (h << 4) + *p++;
  130.     if ((g= h & 0xf0000000) != 0)
  131.         h= (h ^ (g >> 24)) ^ g;
  132.     }
  133.     return h;
  134. }
  135.  
  136. char *strquotechar(byte ch, char *q)
  137. {
  138.     switch(ch) {
  139.     case '\n':
  140.     *q++='\\'; *q++='n'; 
  141.     break;
  142.     case '\r':
  143.     *q++='\\'; *q++='r'; 
  144.     break;
  145.     case '\0':
  146.     *q++='\\'; *q++='0'; 
  147.     break;
  148.     case '\t':
  149.     *q++='\\'; *q++='t'; 
  150.     break;
  151.     case '\v':
  152.     *q++='\\'; *q++='v'; 
  153.     break;
  154.     case '\f':
  155.     *q++='\\'; *q++='f'; 
  156.     break;
  157.     case '\b':
  158.     *q++='\\'; *q++='b'; 
  159.     break;
  160.     default:
  161.     if (Isascii(ch) && Isprint(ch)) {
  162.         *q++= ch;
  163.     } else {
  164.         *q++= '\\';
  165.         *q++= 'x';
  166.         *q++= hexChars[ch/16];
  167.         *q++= hexChars[ch%16]; 
  168.     }
  169.     }
  170.     return q;
  171. }
  172.  
  173. char *BaseName(char *name) 
  174. {
  175.     if (name) {
  176.     if (name[0] == '/' && name[1] == '\0')
  177.         return name;
  178.     char *cp;
  179.     if (cp= strrchr(name, '/'))
  180.         return ++cp;
  181.     return name;
  182.     }
  183.     return "Error in String::BaseName";
  184. }
  185.  
  186. int StrCmp(register byte *s1, register byte *s2, int n, register byte *map)
  187. {
  188.     if (map) {
  189.     if (n < 0) {
  190.         while (map[(byte)*s1] == map[(byte)*s2++])
  191.         if (map[(byte)*s1++] == '\0')
  192.             return 0;
  193.         return map[(byte)*s1] - map[(byte)*--s2];
  194.     } else {
  195.         while (--n >= 0 && map[(byte)*s1] == map[(byte)*s2++])
  196.         if (map[(byte)*s1++] == '\0')
  197.             return 0;
  198.         return (n < 0) ? 0 : map[(byte)*s1] - map[(byte)*--s2];
  199.     }
  200.     } else {
  201.     if (n < 0) {
  202.         while (*s1 == *s2++)
  203.         if (*s1++ == '\0')
  204.             return 0;
  205.         return (int)*s1 - (int)*--s2;
  206.     } else {
  207.         while (--n >= 0 && *s1 == *s2++)
  208.         if (*s1++ == '\0')
  209.             return 0;
  210.         return (n < 0) ? 0 : (int)*s1 - (int)*--s2;
  211.     }
  212.     }
  213. }
  214.  
  215. const cb_size= 1024;
  216. const fld_size= 512;
  217.  
  218. // a circular formating buffer
  219. static char     formbuf[cb_size];       // some slob for form overflow
  220. static char*    bfree= formbuf;
  221. static char*    endbuf= &formbuf[cb_size-1];
  222.  
  223. char* form(const char* va_(fmt), ...)
  224. {
  225.     va_list ap;
  226.     va_start(ap,va_(fmt));
  227.     char *format= (char*) va_(fmt);
  228.     register char *buf= bfree;
  229.  
  230.     if (buf+fld_size > endbuf)  
  231.     buf= formbuf;
  232.  
  233.     register int ll= (int) vsprintf(buf, format, ap);
  234.     if (0 < ll && ll < cb_size)                 // length
  235.         ;
  236.     else if (buf < (char*)ll && (char*)ll < buf+cb_size)    // pointer to trailing 0
  237.         ll= (char*)ll - buf;
  238.     else
  239.         ll= strlen(buf);
  240.     if (fld_size < ll)  // oops
  241.     Fatal("form", "buffer overflow");
  242.     bfree= buf+ll+1;
  243.     va_end(ap);
  244.     return buf;
  245. }
  246.  
  247.